home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1996 #15 / Monster Media Number 15 (Monster Media)(July 1996).ISO / bbs_util / bsrc_260.zip / SRC.ZIP / FOSSIL.C < prev    next >
C/C++ Source or Header  |  1996-03-23  |  13KB  |  662 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      ------------         Bit-Bucket Software, Co.                       */
  5. /*      \ 10001101 /         Writers and Distributors of                    */
  6. /*       \ 011110 /          Freely Available<tm> Software.                 */
  7. /*        \ 1011 /                                                          */
  8. /*         ------                                                           */
  9. /*                                                                          */
  10. /*              (C) Copyright 1987-96, Bit Bucket Software Co.              */
  11. /*                                                                          */
  12. /*           This module was originally written by Bob Hartman              */
  13. /*                                                                          */
  14. /*                  BinkleyTerm FOSSIL version 5 module                     */
  15. /*                                                                          */
  16. /*                                                                          */
  17. /*    For complete  details  of the licensing restrictions, please refer    */
  18. /*    to the License  agreement,  which  is published in its entirety in    */
  19. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.260.    */
  20. /*                                                                          */
  21. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  22. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  23. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  24. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  25. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  26. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  27. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  28. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  29. /*                                                                          */
  30. /*                                                                          */
  31. /* You can contact Bit Bucket Software Co. at any one of the following      */
  32. /* addresses:                                                               */
  33. /*                                                                          */
  34. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:343/491             */
  35. /* P.O. Box 460398                AlterNet 7:42/1491                        */
  36. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  37. /*                                Internet f491.n343.z1.fidonet.org         */
  38. /*                                                                          */
  39. /* Please feel free to contact us at any time to share your comments about  */
  40. /* our software and/or licensing policies.                                  */
  41. /*                                                                          */
  42. /*--------------------------------------------------------------------------*/
  43.  
  44. /* Include this file before any other includes or defines! */
  45.  
  46. #include "includes.h"
  47.  
  48. #ifdef OS_2
  49. void 
  50. fossil_ver (void)
  51. {
  52.     old_fossil = 0;
  53. }
  54.  
  55. /* get_key () - P. Fitzsimmons */
  56. int 
  57. get_key (void)
  58. {
  59.     int c = getch ();
  60.  
  61.     if (!c || c == 0xE0)        /* OS/2 returns 0xE0 if one of the *
  62.                             * grey edit keys are hit          */
  63.         c = getch () << 8;
  64.     return (c);
  65. }
  66. #endif
  67.  
  68. #ifdef _WIN32
  69. void 
  70. fossil_ver (void)
  71. {
  72.     extern int old_fossil;
  73.  
  74.     old_fossil = 0;
  75.  
  76.     /*    (void) _setmode (_fileno (stdin), _O_BINARY); */
  77. }
  78.  
  79. #if 0
  80. short 
  81. KBHit (void)
  82. {
  83.     return _kbhit ();
  84. }
  85.  
  86. short 
  87. GetKBKey (void)
  88. {
  89.     short c;
  90.  
  91.     c = _getch ();
  92.  
  93.     if (!c || c == 0xE0)
  94.         c = _getch () << 8;
  95.     return (c);
  96. }
  97. #endif
  98. #endif
  99.  
  100. #ifdef DOS16
  101.  
  102. int Port = 0;
  103.  
  104. int FailSafeTimer = 0;
  105.  
  106. static void LOCALFUNC fill_buffer (void);
  107. static USHORT ComOutSpace (void);
  108.  
  109. void 
  110. fossil_ver ()
  111. {
  112.     union REGS r;
  113.     struct SREGS s;
  114.  
  115.     char far *q;
  116.  
  117.     q = (char far *) &fossil_info;
  118.  
  119.     r.x.cx = sizeof (struct finfo);
  120.  
  121.     segread (&s);
  122.     s.es = s.ds = FP_SEG (q);
  123.  
  124.     r.x.di = r.x.si = FP_OFF (q);
  125.  
  126.     r.x.dx = Port;
  127.     r.x.ax = 0x1b00;
  128.  
  129.     (void) int86x (0x14, &r, &r, &s);
  130.  
  131.     if ((fossil_info.curr_fossil > 0) && !rev3)
  132.         old_fossil = 0;
  133. }
  134.  
  135. void 
  136. com_kick ()
  137. {
  138.     XON_DISABLE ();                /* Uncork the transmitter */
  139.     XON_ENABLE ();
  140. }
  141.  
  142. unsigned int 
  143. Com_ (char request, byte parm1)
  144. {
  145.     union REGS r;
  146.  
  147.     r.h.ah = request;
  148.     r.h.al = parm1;
  149.     r.x.dx = Port;
  150.  
  151.     return int86 (0x14, &r, &r);
  152. }
  153.  
  154. int 
  155. ComInit (int WhichPort, int failsafe)
  156. {
  157.     union REGS r;
  158.     struct SREGS s;
  159.     char far *ptr = &ctrlc_ctr;
  160.     int ret;
  161.  
  162.     fossil_fetch_pointer = fossil_buffer;
  163.     fossil_count = 0;
  164.  
  165.     r.h.ah = 4;
  166.     r.x.dx = (Port = WhichPort);
  167.     r.x.bx = 0x4f50;
  168.  
  169.     segread (&s);
  170.  
  171.     s.es = s.ds = FP_SEG (ptr);
  172.     r.x.cx = FP_OFF (ptr);
  173.  
  174.     ret = int86x (0x14, &r, &r, &s);
  175.  
  176.     if (ret == 0x1954)
  177.     {
  178.         FailSafeTimer = failsafe;
  179.         r.x.ax = 0x0f01;
  180.         r.x.dx = Port;
  181.         (void) int86 (0x14, &r, &r);
  182.     }
  183.     return (ret);
  184. }
  185.  
  186. int 
  187. com_getc (int t)
  188. {
  189.     long t1;
  190.  
  191.     if (!CHAR_AVAIL ())
  192.     {
  193.         t1 = timerset ((unsigned int) (t * 100));
  194.         while (!CHAR_AVAIL ())
  195.         {
  196.             if (timeup (t1))
  197.             {
  198.                 return (EOF);
  199.             }
  200.  
  201.             /*
  202.           * This should work because we only do TIMED_READ when we have
  203.           * carrier
  204.           */
  205.             if (!CARRIER)
  206.             {
  207.                 return (EOF);
  208.             }
  209.             time_release ();
  210.         }
  211.     }
  212.     return ((unsigned int) (MODEM_IN ()) & 0x00ff);
  213. }
  214.  
  215. int 
  216. modem_in (void)
  217. {
  218.     unsigned char c;
  219.  
  220.     while (fossil_count == 0)
  221.     {
  222.         fill_buffer ();
  223.         if (fossil_count == 0)
  224.             time_release ();
  225.     }
  226.     --fossil_count;
  227.     c = (unsigned char) *fossil_fetch_pointer++;
  228.     return ((int) c);
  229. }
  230.  
  231. int 
  232. peekbyte (void)
  233. {
  234.     unsigned char c;
  235.  
  236.     if (fossil_count == 0)
  237.     {
  238.         fill_buffer ();
  239.         if (fossil_count == 0)
  240.             return (-1);
  241.     }
  242.     c = (unsigned char) *fossil_fetch_pointer;
  243.     return ((int) c);
  244. }
  245.  
  246. static void LOCALFUNC 
  247. fill_buffer (void)
  248. {
  249.     union REGS r;
  250.     struct SREGS s;
  251.     char far *ptr = (char far *) fossil_buffer;
  252.     int ret;
  253.  
  254.     if (fossil_count != 0)
  255.         return;
  256.  
  257.     fossil_fetch_pointer = fossil_buffer;
  258.  
  259.     if (old_fossil == 0)
  260.     {
  261.         r.x.cx = 127;
  262.         r.x.dx = Port;
  263.  
  264.         segread (&s);
  265.  
  266.         r.x.di = r.x.si = FP_OFF (ptr);
  267.         s.es = s.ds = FP_SEG (ptr);
  268.  
  269.         r.x.ax = 0x1800;
  270.  
  271.         fossil_count = int86x (0x14, &r, &r, &s);
  272.     }
  273.     else
  274.     {
  275.         r.x.ax = 0x0c00;
  276.         r.x.dx = Port;
  277.  
  278.         ret = int86 (0x14, &r, &r);
  279.  
  280.         if (ret != -1)
  281.         {
  282.             fossil_count = 1;
  283.             *fossil_fetch_pointer = (char) ret;
  284.             r.x.ax = 0x0200;
  285.             (void) int86 (0x14, &r, &r);
  286.         }
  287.     }
  288. }
  289.  
  290. void 
  291. clear_inbound (void)
  292. {
  293.     union REGS r;
  294.  
  295.     fossil_fetch_pointer = fossil_buffer;
  296.     fossil_count = 0;
  297.  
  298.     r.x.ax = 0x0a00;
  299.     r.x.dx = Port;
  300.  
  301.     (void) int86 (0x14, &r, &r);
  302. }
  303.  
  304. void 
  305. clear_outbound (void)
  306. {
  307.     union REGS r;
  308.  
  309.     out_send_pointer = out_buffer;
  310.     out_count = 0;
  311.  
  312.     r.x.ax = 0x0900;
  313.     r.x.dx = Port;
  314.  
  315.     (void) int86 (0x14, &r, &r);
  316. }
  317.  
  318. int 
  319. modem_status (void)
  320. {
  321.     union REGS r;
  322.     int ret;
  323.  
  324.     r.x.ax = 0x0300;
  325.     r.x.dx = Port;
  326.  
  327.     ret = int86 (0x14, &r, &r);
  328.  
  329.     if (fossil_count != 0)
  330.         ret |= 256;
  331.  
  332.     return (ret);
  333. }
  334.  
  335. void 
  336. do_break (int on_off)
  337. {
  338.     union REGS r;
  339.  
  340.     r.h.al = (char) on_off;
  341.     r.h.ah = 0x1a;
  342.     r.x.dx = Port;
  343.  
  344.     (void) int86 (0x14, &r, &r);
  345. }
  346.  
  347. void 
  348. mdm_enable (unsigned long mask)
  349. {
  350.     union REGS r;
  351.  
  352.     CLEAR_INBOUND ();
  353.  
  354. #ifdef EXTENDED_BAUDRATES
  355.     if (extend_rates)
  356.     {
  357.         r.h.cl = (byte) mask;
  358.         r.h.ch = (comm_bits == 3) ? 3 : 2;
  359.         r.h.bl = (stop_bits == 4) ? 1 : 0;
  360.         switch (parity)
  361.         {
  362.         case 0x08:                /* ODD_PARITY */
  363.             r.h.bh = 1;
  364.             break;
  365.  
  366.         case 0x18:                /* EVEN_PARITY */
  367.             r.h.bh = 2;
  368.             break;
  369.  
  370.         default:
  371.             r.h.bh = 0;
  372.             break;
  373.         }
  374.         r.h.ah = 0x1e;
  375.         r.h.al = 0;
  376.         r.x.dx = Port;
  377.  
  378.         (void) int86 (0x14, &r, &r);
  379.         return;
  380.     }
  381. #endif
  382.  
  383.     r.h.al = (byte) (mask | comm_bits | parity | stop_bits);
  384.     r.h.ah = 0;
  385.     r.x.dx = Port;
  386.  
  387.     (void) int86 (0x14, &r, &r);
  388. }
  389.  
  390. void 
  391. mdm_disable (void)
  392. {
  393.     union REGS r;
  394.  
  395.     fossil_fetch_pointer = fossil_buffer;
  396.     fossil_count = 0;
  397.  
  398.     r.x.ax = 0x0500;
  399.     r.x.dx = Port;
  400.  
  401.     (void) int86 (0x14, &r, &r);
  402. }
  403.  
  404. void 
  405. unbuffer_bytes (void)
  406. {
  407.     if (out_count == 0)
  408.         return;
  409.  
  410.     SENDCHARS ((char far *) out_buffer, out_count, 1);
  411.  
  412.     out_send_pointer = out_buffer;
  413.     out_count = 0;
  414. }
  415.  
  416. void 
  417. buffer_byte (char c)
  418. {
  419.     if (out_count == 128)
  420.         unbuffer_bytes ();
  421.  
  422.     out_count++;
  423.     *out_send_pointer++ = c;
  424. }
  425.  
  426. void 
  427. sendbyte (unsigned char c)
  428. {
  429.     union REGS r;
  430.     int done = 0;
  431.  
  432.     if (out_count != 0)
  433.         unbuffer_bytes ();
  434.  
  435.     while (done == 0)
  436.     {
  437.         r.h.ah = 0x0b;
  438.         r.h.al = c;
  439.         r.x.dx = Port;
  440.  
  441.         done = int86 (0x14, &r, &r);
  442.         if (done == 0)
  443.         {
  444.             (void) peekbyte ();    /* Waiting for output, try to get input */
  445.             time_release ();
  446.         }
  447.     }
  448. }
  449.  
  450. void 
  451. sendchars (char far * str, unsigned len, int dcd)
  452. {
  453.     union REGS r1, r2;
  454.     struct SREGS s;
  455.     long timer = 0L;
  456.     int sent;
  457.  
  458.     if (old_fossil)
  459.     {
  460.         r1.x.ax = 0x0b00;
  461.         r1.x.dx = Port;
  462.  
  463.         while (len != 0)
  464.         {
  465.             r1.h.al = *str;
  466.             if (int86 (0x14, &r1, &r2) != 0)
  467.             {
  468.                 str++;
  469.                 len--;
  470.             }
  471.             else
  472.             {
  473.                 if (FailSafeTimer)
  474.                 {
  475.                     if (timer == 0L)
  476.                         timer = timerset (FailSafeTimer);
  477.                     else
  478.                     {
  479.                         if (timeup (timer))
  480.                         {
  481.                             clear_outbound ();
  482.                             LOWER_DTR ();
  483.                             return;
  484.                         }
  485.                     }
  486.                 }
  487.  
  488.                 (void) peekbyte ();    /* Waiting for output, try to get input */
  489.                 time_release ();
  490.                 if (dcd && !CARRIER)
  491.                     return;
  492.             }
  493.         }
  494.         return;
  495.     }
  496.  
  497.     r1.x.ax = 0x1900;
  498.     r1.x.dx = Port;
  499.  
  500.     segread (&s);
  501.  
  502.     s.es = s.ds = FP_SEG (str);
  503.  
  504.     while (len != 0)
  505.     {
  506.         r1.x.cx = len;
  507.         r1.x.si = r1.x.di = FP_OFF (str);
  508.         sent = int86x (0x14, &r1, &r2, &s);
  509.         if (sent == (int) len)
  510.             return;
  511.  
  512.         len -= sent;
  513.         str += sent;
  514.  
  515.         if (FailSafeTimer)
  516.         {
  517.             if (timer == 0L)
  518.                 timer = timerset (FailSafeTimer);
  519.             else
  520.             {
  521.                 if (timeup (timer))
  522.                 {
  523.                     clear_outbound ();
  524.                     LOWER_DTR ();
  525.                     return;
  526.                 }
  527.             }
  528.         }
  529.  
  530.         (void) peekbyte ();        /* Waiting for output, try to get input */
  531.         time_release ();
  532.         if (dcd && !CARRIER)
  533.             return;
  534.     }
  535. }
  536.  
  537. /* Currently only used by HYDRA */
  538.  
  539. /*
  540.  * This is a lot like ComWrite, but will return the sent-character
  541.  * count if either a timeout occurs or carrier is lost. The timer
  542.  * is specified by passing in a time_t for end-of-time. If zero is
  543.  * passed for the timer, we'll just check for carrier loss.
  544.  *
  545.  */
  546.  
  547. USHORT
  548. ComTXBlockTimeout (BYTE *lpBuf, USHORT cbBuf, ULONG ulTimer)
  549. {
  550.     USHORT cbRemaining = cbBuf;
  551.     USHORT cbToSend;
  552.     BOOL fTimedOut;
  553.  
  554.     fTimedOut = (ulTimer != 0) ? (ulTimer < (ULONG)time (NULL)) : FALSE;
  555.     while (!fTimedOut && CARRIER && cbRemaining)
  556.     {
  557.         cbToSend = ComOutSpace ();
  558.         if ((--cbToSend) > 0)
  559.         {
  560.             if (cbToSend > cbRemaining)
  561.                 cbToSend = cbRemaining;
  562.             sendchars (lpBuf, cbToSend, 1);
  563.             lpBuf += cbToSend;
  564.             cbRemaining -= cbToSend;
  565.         }
  566.         else
  567.             time_release ();
  568.         fTimedOut = (ulTimer != 0) ? (ulTimer < (ULONG)time (NULL)) : FALSE;
  569.     }
  570.     return (cbBuf - cbRemaining);
  571. }
  572.  
  573. USHORT
  574. ComTXRemain (void)
  575. {
  576.     union REGS r1, r2;
  577.     struct SREGS s;
  578.     char far *q;
  579.  
  580.     if (old_fossil)
  581.         return (0);
  582.  
  583.     q = (char far *) &fossil_info;
  584.  
  585.     r1.x.ax = 0x1b00;
  586.     r1.x.cx = sizeof (FOSINFO);
  587.     r1.x.dx = Port;
  588.     segread(&s);
  589.     s.es = s.ds = FP_SEG (q);
  590.     r1.x.di = FP_OFF (q);
  591.     (void) int86x (0x14,&r1,&r2,&s);
  592.  
  593.     return (fossil_info.obufr - fossil_info.ofree);
  594. }
  595.  
  596. static USHORT
  597. ComOutSpace (void)
  598. {
  599.     union REGS r1, r2;
  600.     struct SREGS s;
  601.     char far *q;
  602.  
  603.     if (old_fossil)
  604.         return (1);
  605.  
  606.     q = (char far *) &fossil_info;
  607.  
  608.     r1.x.ax = 0x1b00;
  609.     r1.x.cx = sizeof (FOSINFO);
  610.     r1.x.dx = Port;
  611.     segread(&s);
  612.     s.es = s.ds = FP_SEG (q);
  613.     r1.x.di = FP_OFF (q);
  614.     (void) int86x (0x14,&r1,&r2,&s);
  615.  
  616.     return (fossil_info.ofree);
  617. }
  618.  
  619.  
  620. void 
  621. fossil_gotoxy (int col, int row)
  622. {
  623.     union REGS r;
  624.  
  625.     r.h.dh = (char) row;
  626.     r.h.dl = (char) col;
  627.     r.x.ax = 0x1100;
  628.  
  629.     (void) int86 (0x14, &r, &r);
  630. }
  631.  
  632. int 
  633. fossil_whereami (void)
  634. {
  635.     union REGS r;
  636.  
  637.     r.x.ax = 0x1200;
  638.     (void) int86 (0x14, &r, &r);
  639.     return r.x.dx;
  640. }
  641.  
  642. int 
  643. fossil_wherey (void)
  644. {
  645.     union REGS r;
  646.  
  647.     r.x.ax = 0x1200;
  648.     (void) int86 (0x14, &r, &r);
  649.     return (int) r.h.dh;
  650. }
  651.  
  652. int 
  653. fossil_wherex (void)
  654. {
  655.     union REGS r;
  656.  
  657.     r.x.ax = 0x1200;
  658.     (void) int86 (0x14, &r, &r);
  659.     return (int) r.h.dl;
  660. }
  661. #endif
  662.